home *** CD-ROM | disk | FTP | other *** search
/ Mac Easy 2010 May / Mac Life Ubuntu.iso / casper / filesystem.squashfs / usr / src / linux-headers-2.6.28-15 / include / linux / page-flags.h < prev    next >
Encoding:
C/C++ Source or Header  |  2008-12-24  |  12.0 KB  |  403 lines
  1. /*
  2.  * Macros for manipulating and testing page->flags
  3.  */
  4.  
  5. #ifndef PAGE_FLAGS_H
  6. #define PAGE_FLAGS_H
  7.  
  8. #include <linux/types.h>
  9. #ifndef __GENERATING_BOUNDS_H
  10. #include <linux/mm_types.h>
  11. #include <linux/bounds.h>
  12. #endif /* !__GENERATING_BOUNDS_H */
  13.  
  14. /*
  15.  * Various page->flags bits:
  16.  *
  17.  * PG_reserved is set for special pages, which can never be swapped out. Some
  18.  * of them might not even exist (eg empty_bad_page)...
  19.  *
  20.  * The PG_private bitflag is set on pagecache pages if they contain filesystem
  21.  * specific data (which is normally at page->private). It can be used by
  22.  * private allocations for its own usage.
  23.  *
  24.  * During initiation of disk I/O, PG_locked is set. This bit is set before I/O
  25.  * and cleared when writeback _starts_ or when read _completes_. PG_writeback
  26.  * is set before writeback starts and cleared when it finishes.
  27.  *
  28.  * PG_locked also pins a page in pagecache, and blocks truncation of the file
  29.  * while it is held.
  30.  *
  31.  * page_waitqueue(page) is a wait queue of all tasks waiting for the page
  32.  * to become unlocked.
  33.  *
  34.  * PG_uptodate tells whether the page's contents is valid.  When a read
  35.  * completes, the page becomes uptodate, unless a disk I/O error happened.
  36.  *
  37.  * PG_referenced, PG_reclaim are used for page reclaim for anonymous and
  38.  * file-backed pagecache (see mm/vmscan.c).
  39.  *
  40.  * PG_error is set to indicate that an I/O error occurred on this page.
  41.  *
  42.  * PG_arch_1 is an architecture specific page state bit.  The generic code
  43.  * guarantees that this bit is cleared for a page when it first is entered into
  44.  * the page cache.
  45.  *
  46.  * PG_highmem pages are not permanently mapped into the kernel virtual address
  47.  * space, they need to be kmapped separately for doing IO on the pages.  The
  48.  * struct page (these bits with information) are always mapped into kernel
  49.  * address space...
  50.  *
  51.  * PG_buddy is set to indicate that the page is free and in the buddy system
  52.  * (see mm/page_alloc.c).
  53.  *
  54.  */
  55.  
  56. /*
  57.  * Don't use the *_dontuse flags.  Use the macros.  Otherwise you'll break
  58.  * locked- and dirty-page accounting.
  59.  *
  60.  * The page flags field is split into two parts, the main flags area
  61.  * which extends from the low bits upwards, and the fields area which
  62.  * extends from the high bits downwards.
  63.  *
  64.  *  | FIELD | ... | FLAGS |
  65.  *  N-1           ^       0
  66.  *               (NR_PAGEFLAGS)
  67.  *
  68.  * The fields area is reserved for fields mapping zone, node (for NUMA) and
  69.  * SPARSEMEM section (for variants of SPARSEMEM that require section ids like
  70.  * SPARSEMEM_EXTREME with !SPARSEMEM_VMEMMAP).
  71.  */
  72. enum pageflags {
  73.     PG_locked,        /* Page is locked. Don't touch. */
  74.     PG_error,
  75.     PG_referenced,
  76.     PG_uptodate,
  77.     PG_dirty,
  78.     PG_lru,
  79.     PG_active,
  80.     PG_slab,
  81.     PG_owner_priv_1,    /* Owner use. If pagecache, fs may use*/
  82.     PG_arch_1,
  83.     PG_reserved,
  84.     PG_private,        /* If pagecache, has fs-private data */
  85.     PG_writeback,        /* Page is under writeback */
  86. #ifdef CONFIG_PAGEFLAGS_EXTENDED
  87.     PG_head,        /* A head page */
  88.     PG_tail,        /* A tail page */
  89. #else
  90.     PG_compound,        /* A compound page */
  91. #endif
  92.     PG_swapcache,        /* Swap page: swp_entry_t in private */
  93.     PG_mappedtodisk,    /* Has blocks allocated on-disk */
  94.     PG_reclaim,        /* To be reclaimed asap */
  95.     PG_buddy,        /* Page is free, on buddy lists */
  96.     PG_swapbacked,        /* Page is backed by RAM/swap */
  97. #ifdef CONFIG_UNEVICTABLE_LRU
  98.     PG_unevictable,        /* Page is "unevictable"  */
  99.     PG_mlocked,        /* Page is vma mlocked */
  100. #endif
  101. #ifdef CONFIG_IA64_UNCACHED_ALLOCATOR
  102.     PG_uncached,        /* Page has been mapped as uncached */
  103. #endif
  104.     __NR_PAGEFLAGS,
  105.  
  106.     /* Filesystems */
  107.     PG_checked = PG_owner_priv_1,
  108.  
  109.     /* XEN */
  110.     PG_pinned = PG_owner_priv_1,
  111.     PG_savepinned = PG_dirty,
  112.  
  113.     /* SLOB */
  114.     PG_slob_page = PG_active,
  115.     PG_slob_free = PG_private,
  116.  
  117.     /* SLUB */
  118.     PG_slub_frozen = PG_active,
  119.     PG_slub_debug = PG_error,
  120. };
  121.  
  122. #ifndef __GENERATING_BOUNDS_H
  123.  
  124. /*
  125.  * Macros to create function definitions for page flags
  126.  */
  127. #define TESTPAGEFLAG(uname, lname)                    \
  128. static inline int Page##uname(struct page *page)             \
  129.             { return test_bit(PG_##lname, &page->flags); }
  130.  
  131. #define SETPAGEFLAG(uname, lname)                    \
  132. static inline void SetPage##uname(struct page *page)            \
  133.             { set_bit(PG_##lname, &page->flags); }
  134.  
  135. #define CLEARPAGEFLAG(uname, lname)                    \
  136. static inline void ClearPage##uname(struct page *page)            \
  137.             { clear_bit(PG_##lname, &page->flags); }
  138.  
  139. #define __SETPAGEFLAG(uname, lname)                    \
  140. static inline void __SetPage##uname(struct page *page)            \
  141.             { __set_bit(PG_##lname, &page->flags); }
  142.  
  143. #define __CLEARPAGEFLAG(uname, lname)                    \
  144. static inline void __ClearPage##uname(struct page *page)        \
  145.             { __clear_bit(PG_##lname, &page->flags); }
  146.  
  147. #define TESTSETFLAG(uname, lname)                    \
  148. static inline int TestSetPage##uname(struct page *page)            \
  149.         { return test_and_set_bit(PG_##lname, &page->flags); }
  150.  
  151. #define TESTCLEARFLAG(uname, lname)                    \
  152. static inline int TestClearPage##uname(struct page *page)        \
  153.         { return test_and_clear_bit(PG_##lname, &page->flags); }
  154.  
  155.  
  156. #define PAGEFLAG(uname, lname) TESTPAGEFLAG(uname, lname)        \
  157.     SETPAGEFLAG(uname, lname) CLEARPAGEFLAG(uname, lname)
  158.  
  159. #define __PAGEFLAG(uname, lname) TESTPAGEFLAG(uname, lname)        \
  160.     __SETPAGEFLAG(uname, lname)  __CLEARPAGEFLAG(uname, lname)
  161.  
  162. #define PAGEFLAG_FALSE(uname)                         \
  163. static inline int Page##uname(struct page *page)             \
  164.             { return 0; }
  165.  
  166. #define TESTSCFLAG(uname, lname)                    \
  167.     TESTSETFLAG(uname, lname) TESTCLEARFLAG(uname, lname)
  168.  
  169. #define SETPAGEFLAG_NOOP(uname)                        \
  170. static inline void SetPage##uname(struct page *page) {  }
  171.  
  172. #define CLEARPAGEFLAG_NOOP(uname)                    \
  173. static inline void ClearPage##uname(struct page *page) {  }
  174.  
  175. #define __CLEARPAGEFLAG_NOOP(uname)                    \
  176. static inline void __ClearPage##uname(struct page *page) {  }
  177.  
  178. #define TESTCLEARFLAG_FALSE(uname)                    \
  179. static inline int TestClearPage##uname(struct page *page) { return 0; }
  180.  
  181. struct page;    /* forward declaration */
  182.  
  183. TESTPAGEFLAG(Locked, locked)
  184. PAGEFLAG(Error, error)
  185. PAGEFLAG(Referenced, referenced) TESTCLEARFLAG(Referenced, referenced)
  186. PAGEFLAG(Dirty, dirty) TESTSCFLAG(Dirty, dirty) __CLEARPAGEFLAG(Dirty, dirty)
  187. PAGEFLAG(LRU, lru) __CLEARPAGEFLAG(LRU, lru)
  188. PAGEFLAG(Active, active) __CLEARPAGEFLAG(Active, active)
  189.     TESTCLEARFLAG(Active, active)
  190. __PAGEFLAG(Slab, slab)
  191. PAGEFLAG(Checked, checked)        /* Used by some filesystems */
  192. PAGEFLAG(Pinned, pinned) TESTSCFLAG(Pinned, pinned)    /* Xen */
  193. PAGEFLAG(SavePinned, savepinned);            /* Xen */
  194. PAGEFLAG(Reserved, reserved) __CLEARPAGEFLAG(Reserved, reserved)
  195. PAGEFLAG(Private, private) __CLEARPAGEFLAG(Private, private)
  196.     __SETPAGEFLAG(Private, private)
  197. PAGEFLAG(SwapBacked, swapbacked) __CLEARPAGEFLAG(SwapBacked, swapbacked)
  198.  
  199. __PAGEFLAG(SlobPage, slob_page)
  200. __PAGEFLAG(SlobFree, slob_free)
  201.  
  202. __PAGEFLAG(SlubFrozen, slub_frozen)
  203. __PAGEFLAG(SlubDebug, slub_debug)
  204.  
  205. /*
  206.  * Only test-and-set exist for PG_writeback.  The unconditional operators are
  207.  * risky: they bypass page accounting.
  208.  */
  209. TESTPAGEFLAG(Writeback, writeback) TESTSCFLAG(Writeback, writeback)
  210. __PAGEFLAG(Buddy, buddy)
  211. PAGEFLAG(MappedToDisk, mappedtodisk)
  212.  
  213. /* PG_readahead is only used for file reads; PG_reclaim is only for writes */
  214. PAGEFLAG(Reclaim, reclaim) TESTCLEARFLAG(Reclaim, reclaim)
  215. PAGEFLAG(Readahead, reclaim)        /* Reminder to do async read-ahead */
  216.  
  217. #ifdef CONFIG_HIGHMEM
  218. /*
  219.  * Must use a macro here due to header dependency issues. page_zone() is not
  220.  * available at this point.
  221.  */
  222. #define PageHighMem(__p) is_highmem(page_zone(__p))
  223. #else
  224. PAGEFLAG_FALSE(HighMem)
  225. #endif
  226.  
  227. #ifdef CONFIG_SWAP
  228. PAGEFLAG(SwapCache, swapcache)
  229. #else
  230. PAGEFLAG_FALSE(SwapCache)
  231. #endif
  232.  
  233. #ifdef CONFIG_UNEVICTABLE_LRU
  234. PAGEFLAG(Unevictable, unevictable) __CLEARPAGEFLAG(Unevictable, unevictable)
  235.     TESTCLEARFLAG(Unevictable, unevictable)
  236.  
  237. #define MLOCK_PAGES 1
  238. PAGEFLAG(Mlocked, mlocked) __CLEARPAGEFLAG(Mlocked, mlocked)
  239.     TESTSCFLAG(Mlocked, mlocked)
  240.  
  241. #else
  242.  
  243. #define MLOCK_PAGES 0
  244. PAGEFLAG_FALSE(Mlocked)
  245.     SETPAGEFLAG_NOOP(Mlocked) TESTCLEARFLAG_FALSE(Mlocked)
  246.  
  247. PAGEFLAG_FALSE(Unevictable) TESTCLEARFLAG_FALSE(Unevictable)
  248.     SETPAGEFLAG_NOOP(Unevictable) CLEARPAGEFLAG_NOOP(Unevictable)
  249.     __CLEARPAGEFLAG_NOOP(Unevictable)
  250. #endif
  251.  
  252. #ifdef CONFIG_IA64_UNCACHED_ALLOCATOR
  253. PAGEFLAG(Uncached, uncached)
  254. #else
  255. PAGEFLAG_FALSE(Uncached)
  256. #endif
  257.  
  258. static inline int PageUptodate(struct page *page)
  259. {
  260.     int ret = test_bit(PG_uptodate, &(page)->flags);
  261.  
  262.     /*
  263.      * Must ensure that the data we read out of the page is loaded
  264.      * _after_ we've loaded page->flags to check for PageUptodate.
  265.      * We can skip the barrier if the page is not uptodate, because
  266.      * we wouldn't be reading anything from it.
  267.      *
  268.      * See SetPageUptodate() for the other side of the story.
  269.      */
  270.     if (ret)
  271.         smp_rmb();
  272.  
  273.     return ret;
  274. }
  275.  
  276. static inline void __SetPageUptodate(struct page *page)
  277. {
  278.     smp_wmb();
  279.     __set_bit(PG_uptodate, &(page)->flags);
  280. }
  281.  
  282. static inline void SetPageUptodate(struct page *page)
  283. {
  284. #ifdef CONFIG_S390
  285.     if (!test_and_set_bit(PG_uptodate, &page->flags))
  286.         page_clear_dirty(page);
  287. #else
  288.     /*
  289.      * Memory barrier must be issued before setting the PG_uptodate bit,
  290.      * so that all previous stores issued in order to bring the page
  291.      * uptodate are actually visible before PageUptodate becomes true.
  292.      *
  293.      * s390 doesn't need an explicit smp_wmb here because the test and
  294.      * set bit already provides full barriers.
  295.      */
  296.     smp_wmb();
  297.     set_bit(PG_uptodate, &(page)->flags);
  298. #endif
  299. }
  300.  
  301. CLEARPAGEFLAG(Uptodate, uptodate)
  302.  
  303. extern void cancel_dirty_page(struct page *page, unsigned int account_size);
  304.  
  305. int test_clear_page_writeback(struct page *page);
  306. int test_set_page_writeback(struct page *page);
  307.  
  308. static inline void set_page_writeback(struct page *page)
  309. {
  310.     test_set_page_writeback(page);
  311. }
  312.  
  313. #ifdef CONFIG_PAGEFLAGS_EXTENDED
  314. /*
  315.  * System with lots of page flags available. This allows separate
  316.  * flags for PageHead() and PageTail() checks of compound pages so that bit
  317.  * tests can be used in performance sensitive paths. PageCompound is
  318.  * generally not used in hot code paths.
  319.  */
  320. __PAGEFLAG(Head, head)
  321. __PAGEFLAG(Tail, tail)
  322.  
  323. static inline int PageCompound(struct page *page)
  324. {
  325.     return page->flags & ((1L << PG_head) | (1L << PG_tail));
  326.  
  327. }
  328. #else
  329. /*
  330.  * Reduce page flag use as much as possible by overlapping
  331.  * compound page flags with the flags used for page cache pages. Possible
  332.  * because PageCompound is always set for compound pages and not for
  333.  * pages on the LRU and/or pagecache.
  334.  */
  335. TESTPAGEFLAG(Compound, compound)
  336. __PAGEFLAG(Head, compound)
  337.  
  338. /*
  339.  * PG_reclaim is used in combination with PG_compound to mark the
  340.  * head and tail of a compound page. This saves one page flag
  341.  * but makes it impossible to use compound pages for the page cache.
  342.  * The PG_reclaim bit would have to be used for reclaim or readahead
  343.  * if compound pages enter the page cache.
  344.  *
  345.  * PG_compound & PG_reclaim    => Tail page
  346.  * PG_compound & ~PG_reclaim    => Head page
  347.  */
  348. #define PG_head_tail_mask ((1L << PG_compound) | (1L << PG_reclaim))
  349.  
  350. static inline int PageTail(struct page *page)
  351. {
  352.     return ((page->flags & PG_head_tail_mask) == PG_head_tail_mask);
  353. }
  354.  
  355. static inline void __SetPageTail(struct page *page)
  356. {
  357.     page->flags |= PG_head_tail_mask;
  358. }
  359.  
  360. static inline void __ClearPageTail(struct page *page)
  361. {
  362.     page->flags &= ~PG_head_tail_mask;
  363. }
  364.  
  365. #endif /* !PAGEFLAGS_EXTENDED */
  366.  
  367. #ifdef CONFIG_UNEVICTABLE_LRU
  368. #define __PG_UNEVICTABLE    (1 << PG_unevictable)
  369. #define __PG_MLOCKED        (1 << PG_mlocked)
  370. #else
  371. #define __PG_UNEVICTABLE    0
  372. #define __PG_MLOCKED        0
  373. #endif
  374.  
  375. #define PAGE_FLAGS    (1 << PG_lru   | 1 << PG_private   | 1 << PG_locked | \
  376.              1 << PG_buddy | 1 << PG_writeback | \
  377.              1 << PG_slab  | 1 << PG_swapcache | 1 << PG_active | \
  378.              __PG_UNEVICTABLE | __PG_MLOCKED)
  379.  
  380. /*
  381.  * Flags checked in bad_page().  Pages on the free list should not have
  382.  * these flags set.  It they are, there is a problem.
  383.  */
  384. #define PAGE_FLAGS_CLEAR_WHEN_BAD (PAGE_FLAGS | \
  385.         1 << PG_reclaim | 1 << PG_dirty | 1 << PG_swapbacked)
  386.  
  387. /*
  388.  * Flags checked when a page is freed.  Pages being freed should not have
  389.  * these flags set.  It they are, there is a problem.
  390.  */
  391. #define PAGE_FLAGS_CHECK_AT_FREE (PAGE_FLAGS | 1 << PG_reserved)
  392.  
  393. /*
  394.  * Flags checked when a page is prepped for return by the page allocator.
  395.  * Pages being prepped should not have these flags set.  It they are, there
  396.  * is a problem.
  397.  */
  398. #define PAGE_FLAGS_CHECK_AT_PREP (PAGE_FLAGS | \
  399.         1 << PG_reserved | 1 << PG_dirty | 1 << PG_swapbacked)
  400.  
  401. #endif /* !__GENERATING_BOUNDS_H */
  402. #endif    /* PAGE_FLAGS_H */
  403.